/**
 * 系统配置模块 - 阈值设置功能
 * 处理阈值设置的获取和修改
 */

// 初始化阈值设置模块
function initThresholdSettings() {
    console.log('初始化阈值设置模块');
    
    // 加载阈值设置数据
    loadThresholdSettings();
    
    // 绑定修改按钮事件
    bindThresholdEditButtons();
}

/**
 * 从Android获取阈值设置数据
 */
function loadThresholdSettings() {
    console.log('正在加载阈值设置数据...');
    
    // 检查是否应该使用模拟数据
    if (typeof shouldUseMockData === 'function' && shouldUseMockData()) {
        // 使用模拟数据
        if (window.ThresholdSettingMockData && typeof window.ThresholdSettingMockData.getThresholdSettings === 'function') {
            window.ThresholdSettingMockData.getThresholdSettings()
                .then(response => {
                    console.log('获取阈值设置数据成功:', response);
                    if (response.success && response.data) {
                        updateThresholdUI(response.data);
                    }
                })
                .catch(error => {
                    console.error('获取模拟阈值设置数据出错:', error);
                    showToast('获取阈值设置数据失败', 'error');
                });
        } else {
            console.error('ThresholdSettingMockData 未定义或 getThresholdSettings 方法不可用');
            const mockData = getMockThresholdSettings();
            updateThresholdUI(mockData);
        }
        return;
    }
    
    // 调用Android接口获取阈值设置数据
    callAndroidMethodAsync('getThresholdSettings', {})
        .then(response => {
            console.log('获取阈值设置数据成功:', response);
            
            if (response.success && response.data) {
                // 更新页面上的阈值设置数据
                updateThresholdUI(response.data);
            } else {
                console.error('获取阈值设置数据失败:', response.message || '未知错误');
                showToast('获取阈值设置数据失败: ' + (response.message || '未知错误'), 'error');
            }
        })
        .catch(error => {
            console.error('调用Android接口出错:', error);
            // 使用模拟数据作为备用
            const mockData = getMockThresholdSettings();
            updateThresholdUI(mockData);
        });
}

/**
 * 更新阈值设置UI
 * @param {Array} thresholdSettings 阈值设置数据
 */
function updateThresholdUI(thresholdSettings) {
    if (!thresholdSettings || !Array.isArray(thresholdSettings)) {
        console.warn('无效的阈值设置数据');
        return;
    }
    
    // 遍历阈值设置数据，更新表格
    thresholdSettings.forEach(setting => {
        const row = document.querySelector(`tr[data-param-type="${setting.paramType}"]`);
        if (row) {
            // 更新最小值
            const minCell = row.querySelector('td[data-param="min"] .value-text');
            if (minCell) {
                minCell.textContent = setting.minValue;
            }
            
            // 更新最大值
            const maxCell = row.querySelector('td[data-param="max"] .value-text');
            if (maxCell) {
                maxCell.textContent = setting.maxValue;
            }
        }
    });
    
    console.log('阈值设置UI更新完成');
}

/**
 * 绑定阈值修改按钮事件
 */
function bindThresholdEditButtons() {
    document.querySelectorAll('.btn-edit-threshold').forEach(button => {
        button.addEventListener('click', function() {
            const row = this.closest('tr');
            const paramType = row.getAttribute('data-param-type');
            const paramName = row.cells[0].textContent;
            const minValue = row.querySelector('td[data-param="min"] .value-text').textContent;
            const maxValue = row.querySelector('td[data-param="max"] .value-text').textContent;
            const unit = row.cells[3].textContent;
            
            showThresholdEditDialog(paramType, paramName, minValue, maxValue, unit);
        });
    });
}

/**
 * 显示阈值编辑对话框
 * @param {string} paramType 参数类型
 * @param {string} paramName 参数名称
 * @param {string|number} minValue 最小值
 * @param {string|number} maxValue 最大值
 * @param {string} unit 单位
 */
function showThresholdEditDialog(paramType, paramName, minValue, maxValue, unit) {
    // 使用通用表单模态框
    showFormModal({
        title: `修改${paramName}阈值`,
        fields: [
            {
                name: 'minValue',
                label: `下限阈值 (${unit})`,
                type: 'number',
                value: minValue,
                required: true,
                step: paramType === 'co2' || paramType === 'ph3' ? '0.01' : '1'
            },
            {
                name: 'maxValue',
                label: `上限阈值 (${unit})`,
                type: 'number',
                value: maxValue,
                required: true,
                step: paramType === 'co2' || paramType === 'ph3' ? '0.01' : '1'
            }
        ],
        submitText: '保存',
        cancelText: '取消',
        closeOnBackdropClick: false, // 禁止点击背景关闭弹框
        onSubmit: function(formData) {
            // 验证数据
            const min = parseFloat(formData.minValue);
            const max = parseFloat(formData.maxValue);
            
            if (isNaN(min) || isNaN(max)) {
                showToast('请输入有效的数值', 'warning');
                return;
            }
            
            if (min > max) {
                showToast('下限阈值不能大于上限阈值', 'warning');
                return;
            }
            
            // 构建保存数据
            const saveData = {
                paramType: paramType,
                minValue: min,
                maxValue: max,
                unit: unit
            };
            
            // 保存数据
            updateThresholdSetting(saveData, paramName);
        }
    });
}

/**
 * 更新单个阈值设置
 * @param {Object} data 阈值设置数据
 * @param {string} paramName 参数名称
 */
function updateThresholdSetting(data, paramName) {
    console.log('更新阈值设置:', data);
    
    // 检查是否应该使用模拟数据
    if (typeof shouldUseMockData === 'function' && shouldUseMockData()) {
        // 使用模拟数据
        if (window.ThresholdSettingMockData && typeof window.ThresholdSettingMockData.updateThresholdSetting === 'function') {
            window.ThresholdSettingMockData.updateThresholdSetting(data)
                .then(response => {
                    console.log('更新阈值设置结果:', response);
                    if (response.success) {
                        updateThresholdRowUI(data.paramType, data.minValue, data.maxValue);
                        showToast(`${paramName}阈值范围已更新`, 'success');
                    } else {
                        showToast('更新阈值范围失败: ' + (response.message || '未知错误'), 'error');
                    }
                })
                .catch(error => {
                    console.error('调用模拟接口出错:', error);
                    showToast('更新阈值范围失败', 'error');
                });
        } else {
            console.warn('ThresholdSettingMockData 未定义或 updateThresholdSetting 方法不可用');
            // 简单模拟保存成功
            updateThresholdRowUI(data.paramType, data.minValue, data.maxValue);
            showToast(`${paramName}阈值范围已更新`, 'success');
        }
        return;
    }
    
    // 调用Android接口更新阈值设置
    callAndroidMethodAsync('updateThresholdSetting', data)
        .then(response => {
            console.log('更新阈值设置结果:', response);
            
            if (response.success) {
                // 更新UI
                updateThresholdRowUI(data.paramType, data.minValue, data.maxValue);
                showToast(`${paramName}阈值范围已更新`, 'success');
            } else {
                console.error('更新阈值范围失败:', response.message || '未知错误');
                showToast('更新阈值范围失败: ' + (response.message || '未知错误'), 'error');
            }
        })
        .catch(error => {
            console.error('调用Android接口出错:', error);
            showToast('更新阈值范围失败: ' + error.message, 'error');
        });
}

/**
 * 更新单行阈值设置UI
 * @param {string} paramType 参数类型
 * @param {number} minValue 最小值
 * @param {number} maxValue 最大值
 */
function updateThresholdRowUI(paramType, minValue, maxValue) {
    const row = document.querySelector(`tr[data-param-type="${paramType}"]`);
    if (row) {
        // 更新最小值
        const minCell = row.querySelector('td[data-param="min"] .value-text');
        if (minCell) {
            minCell.textContent = minValue;
        }
        
        // 更新最大值
        const maxCell = row.querySelector('td[data-param="max"] .value-text');
        if (maxCell) {
            maxCell.textContent = maxValue;
        }
    }
}

/**
 * 获取模拟阈值设置数据
 * @returns {Array} 模拟阈值设置数据
 */
function getMockThresholdSettings() {
    return [
        {
            paramType: 'temperature',
            minValue: 5,
            maxValue: 35,
            unit: '℃',
            description: '粮食储存适宜温度范围'
        },
        {
            paramType: 'humidity',
            minValue: 45,
            maxValue: 75,
            unit: '%',
            description: '粮食储存适宜湿度范围'
        },
        {
            paramType: 'pest',
            minValue: 0,
            maxValue: 20,
            unit: '只/kg',
            description: '粮食虫害警戒阈值'
        },
        {
            paramType: 'oxygen',
            minValue: 19,
            maxValue: 23,
            unit: '%',
            description: '安全氧气浓度范围'
        },
        {
            paramType: 'co2',
            minValue: 0,
            maxValue: 0.5,
            unit: '%',
            description: '安全二氧化碳浓度范围'
        },
        {
            paramType: 'ph3',
            minValue: 0,
            maxValue: 0.01,
            unit: 'mg/m³',
            description: '安全磷化氢浓度范围'
        }
    ];
}

// 导出公共函数
window.ThresholdSettings = {
    init: initThresholdSettings,
    loadData: loadThresholdSettings
}; 